#!/bin/bash
# 超级修复脚本 - 彻底解决Flask JWT 401错误
# 这个脚本会尝试所有可能的修复方法，直到问题解决

echo "🚨 开始超级修复 - 彻底解决Flask JWT 401错误"
echo "================================================"

SECRET_KEY="aqm-jwt-secret-1749456354171-rLD9xAdYFvBlNXa8vop3Um9zJ6l9V8qDSkhBbzVwVbCsHKvOaNsWiFmi34VpNlDD"
APP_DIR="/www/wwwroot/flask-auth"
LOG_FILE="/tmp/super_fix_$(date +%Y%m%d_%H%M%S).log"

# 日志函数
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

# 测试API函数
test_api() {
    log "🧪 测试API状态..."
    
    # 测试基础连接
    if curl -s -f http://localhost:5000/api/auth/test > /dev/null 2>&1; then
        log "✅ 基础API连接正常"
    else
        log "❌ 基础API连接失败"
        return 1
    fi
    
    # 测试登录
    local login_result=$(curl -s -X POST -H "Content-Type: application/json" \
        -d '{"username":"admin","password":"admin"}' \
        http://localhost:5000/auth/login)
    
    if echo "$login_result" | grep -q "access_token\|token"; then
        log "✅ 登录成功"
        
        # 提取token并测试
        local token=$(echo "$login_result" | python3 -c "
import sys, json
try:
    data = json.load(sys.stdin)
    print(data.get('access_token', data.get('data', {}).get('token', '')))
except: pass
")
        
        if [ ! -z "$token" ]; then
            local auth_test=$(curl -s -H "Authorization: Bearer $token" \
                http://localhost:5000/dashboard/overview)
            
            if echo "$auth_test" | grep -v "401\|Unauthorized" > /dev/null; then
                log "🎉 JWT认证测试成功！问题已解决！"
                return 0
            else
                log "❌ JWT认证仍然失败 (401错误)"
                return 1
            fi
        fi
    else
        log "❌ 登录失败"
        return 1
    fi
}

# 备份配置
backup_config() {
    log "📋 备份配置文件..."
    cp $APP_DIR/app/config.py $APP_DIR/app/config.py.super_backup_$(date +%Y%m%d_%H%M%S)
    log "✅ 配置文件已备份"
}

# 修复方法1：彻底清理和重启
method_1_force_restart() {
    log "🔥 方法1：执行彻底清理和重启..."
    
    # 终止所有相关进程
    log "终止所有Python/Flask进程..."
    pkill -9 -f python 2>/dev/null || true
    pkill -9 -f flask 2>/dev/null || true
    pkill -9 -f gunicorn 2>/dev/null || true
    sleep 5
    
    # 清理缓存
    log "清理缓存文件..."
    find /tmp -name "*.pyc" -delete 2>/dev/null || true
    find $APP_DIR -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
    find $APP_DIR -name "*.pyc" -delete 2>/dev/null || true
    
    # 重新启动
    log "重新启动Flask应用..."
    cd $APP_DIR
    export SECRET_KEY="$SECRET_KEY"
    nohup python3 run.py > /tmp/flask_method1.log 2>&1 &
    sleep 8
    
    # 测试结果
    if test_api; then
        log "🎉 方法1成功！问题已解决！"
        return 0
    else
        log "❌ 方法1失败，尝试下一个方法..."
        return 1
    fi
}

# 修复方法2：硬编码SECRET_KEY
method_2_hardcode() {
    log "🛠️ 方法2：硬编码SECRET_KEY..."
    
    # 备份并修改配置文件
    sed -i "s/SECRET_KEY = os.getenv('SECRET_KEY'.*)/SECRET_KEY = '$SECRET_KEY'/g" $APP_DIR/app/config.py
    
    # 验证修改
    if grep -q "$SECRET_KEY" $APP_DIR/app/config.py; then
        log "✅ SECRET_KEY已硬编码到配置文件"
    else
        log "⚠️ 自动修改失败，尝试手动替换..."
        # 手动替换
        python3 -c "
import re
with open('$APP_DIR/app/config.py', 'r') as f:
    content = f.read()
content = re.sub(r'SECRET_KEY = os\.getenv\(.*?\)', \"SECRET_KEY = '$SECRET_KEY'\", content)
with open('$APP_DIR/app/config.py', 'w') as f:
    f.write(content)
"
    fi
    
    # 重启应用
    log "重启Flask应用..."
    pkill -9 -f python 2>/dev/null || true
    sleep 3
    cd $APP_DIR
    nohup python3 run.py > /tmp/flask_method2.log 2>&1 &
    sleep 8
    
    # 测试结果
    if test_api; then
        log "🎉 方法2成功！问题已解决！"
        return 0
    else
        log "❌ 方法2失败，尝试下一个方法..."
        return 1
    fi
}

# 修复方法3：环境变量 + 配置文件双重设置
method_3_double_setup() {
    log "🔄 方法3：环境变量 + 配置文件双重设置..."
    
    # 设置环境变量
    echo "SECRET_KEY=$SECRET_KEY" > $APP_DIR/.env
    export SECRET_KEY="$SECRET_KEY"
    
    # 同时确保配置文件正确
    sed -i "s/SECRET_KEY = os.getenv('SECRET_KEY'.*)/SECRET_KEY = os.getenv('SECRET_KEY', '$SECRET_KEY')/g" $APP_DIR/app/config.py
    
    # 创建启动脚本
    cat > $APP_DIR/start_with_env.py << EOF
import os
import sys
sys.path.insert(0, '.')

# 强制设置SECRET_KEY
os.environ['SECRET_KEY'] = '$SECRET_KEY'

from app import create_app
app = create_app()

# 再次确保SECRET_KEY正确
app.config['SECRET_KEY'] = '$SECRET_KEY'

if __name__ == '__main__':
    print(f"Starting Flask with SECRET_KEY: {app.config['SECRET_KEY'][:20]}...")
    app.run(host='0.0.0.0', port=5000, debug=False)
EOF
    
    # 重启应用
    log "使用环境变量启动Flask..."
    pkill -9 -f python 2>/dev/null || true
    sleep 3
    cd $APP_DIR
    SECRET_KEY="$SECRET_KEY" nohup python3 start_with_env.py > /tmp/flask_method3.log 2>&1 &
    sleep 8
    
    # 测试结果
    if test_api; then
        log "🎉 方法3成功！问题已解决！"
        return 0
    else
        log "❌ 方法3失败，尝试下一个方法..."
        return 1
    fi
}

# 修复方法4：直接修改运行时配置
method_4_runtime_config() {
    log "⚡ 方法4：直接修改运行时配置..."
    
    # 创建运行时配置修改脚本
    cat > $APP_DIR/runtime_fix.py << EOF
import os
import sys
import time
import requests
import json

# 设置SECRET_KEY
SECRET_KEY = '$SECRET_KEY'
os.environ['SECRET_KEY'] = SECRET_KEY

# 启动Flask应用
sys.path.insert(0, '.')
from app import create_app

app = create_app()
app.config['SECRET_KEY'] = SECRET_KEY

print(f"Flask应用已启动，SECRET_KEY: {app.config['SECRET_KEY'][:20]}...")

# 测试函数
def test_auth():
    try:
        # 测试登录
        response = requests.post('http://localhost:5000/auth/login', 
                               json={'username': 'admin', 'password': 'admin'},
                               headers={'Content-Type': 'application/json'})
        
        if response.status_code == 200:
            data = response.json()
            token = data.get('access_token') or data.get('data', {}).get('token')
            
            if token:
                # 测试token验证
                test_response = requests.get('http://localhost:5000/dashboard/overview',
                                           headers={'Authorization': f'Bearer {token}'})
                
                if test_response.status_code == 200:
                    print("✅ 认证测试成功！")
                    return True
                else:
                    print(f"❌ 认证测试失败: {test_response.status_code}")
        
        print(f"❌ 登录失败: {response.status_code}")
        return False
    except Exception as e:
        print(f"❌ 测试过程出错: {e}")
        return False

# 启动应用
if __name__ == '__main__':
    print("启动Flask应用...")
    
    # 在另一个线程中运行测试
    import threading
    def delayed_test():
        time.sleep(5)
        test_auth()
    
    test_thread = threading.Thread(target=delayed_test)
    test_thread.start()
    
    # 启动Flask
    app.run(host='0.0.0.0', port=5000, debug=False)
EOF
    
    # 运行修复脚本
    log "运行运行时配置修复..."
    pkill -9 -f python 2>/dev/null || true
    sleep 3
    cd $APP_DIR
    nohup python3 runtime_fix.py > /tmp/flask_method4.log 2>&1 &
    sleep 10
    
    # 测试结果
    if test_api; then
        log "🎉 方法4成功！问题已解决！"
        return 0
    else
        log "❌ 方法4失败，尝试最后的方法..."
        return 1
    fi
}

# 修复方法5：强制端口和完全重置
method_5_complete_reset() {
    log "🔥 方法5：完全重置和强制修复..."
    
    # 完全停止服务
    log "完全停止所有相关服务..."
    pkill -9 -f python 2>/dev/null || true
    pkill -9 -f flask 2>/dev/null || true
    fuser -k 5000/tcp 2>/dev/null || true
    sleep 5
    
    # 重置配置文件
    log "重置配置文件..."
    cat > $APP_DIR/app/config.py << EOF
import os
from datetime import timedelta

class Config:
    # 强制设置SECRET_KEY
    SECRET_KEY = '$SECRET_KEY'
    
    # 数据库配置
    MYSQL_HOST = os.getenv('MYSQL_HOST', 'localhost')
    MYSQL_PORT = int(os.getenv('MYSQL_PORT', 3306))
    MYSQL_USER = os.getenv('MYSQL_USER', 'test2')
    MYSQL_PASSWORD = os.getenv('MYSQL_PASSWORD', '123456')
    MYSQL_DB = os.getenv('MYSQL_DB', 'test2')
    
    # JWT配置
    JWT_SECRET_KEY = SECRET_KEY
    JWT_ACCESS_TOKEN_EXPIRES = timedelta(hours=24)
    
    # 其他配置
    DEBUG = False
    TESTING = False
    LOG_LEVEL = os.getenv('LOG_LEVEL', 'INFO')

# 为了向后兼容，直接设置变量
SECRET_KEY = '$SECRET_KEY'
MYSQL_HOST = 'localhost'
MYSQL_PORT = 3306
MYSQL_USER = 'test2'
MYSQL_PASSWORD = '123456'
MYSQL_DB = 'test2'
DEBUG = False
LOG_LEVEL = 'INFO'
EOF
    
    # 强制启动
    log "强制启动Flask应用..."
    cd $APP_DIR
    SECRET_KEY="$SECRET_KEY" python3 -c "
import os
os.environ['SECRET_KEY'] = '$SECRET_KEY'
import sys
sys.path.insert(0, '.')
from app import create_app
app = create_app()
app.config['SECRET_KEY'] = '$SECRET_KEY'
print('Flask应用启动中...')
app.run(host='0.0.0.0', port=5000, debug=False)
" > /tmp/flask_method5.log 2>&1 &
    
    sleep 10
    
    # 最终测试
    if test_api; then
        log "🎉 方法5成功！问题已解决！"
        return 0
    else
        log "❌ 所有方法都失败了，需要手动检查"
        return 1
    fi
}

# 主执行流程
main() {
    log "🚀 开始超级修复流程..."
    
    # 检查应用目录
    if [ ! -d "$APP_DIR" ]; then
        log "❌ Flask应用目录不存在: $APP_DIR"
        log "请检查应用路径是否正确"
        exit 1
    fi
    
    # 备份配置
    backup_config
    
    # 依次尝试各种修复方法
    log "📋 将依次尝试5种修复方法..."
    
    if method_1_force_restart; then
        log "🎉 超级修复完成！使用了方法1"
        exit 0
    fi
    
    if method_2_hardcode; then
        log "🎉 超级修复完成！使用了方法2"
        exit 0
    fi
    
    if method_3_double_setup; then
        log "🎉 超级修复完成！使用了方法3"
        exit 0
    fi
    
    if method_4_runtime_config; then
        log "🎉 超级修复完成！使用了方法4"
        exit 0
    fi
    
    if method_5_complete_reset; then
        log "🎉 超级修复完成！使用了方法5"
        exit 0
    fi
    
    # 如果所有方法都失败
    log "❌ 所有修复方法都失败了"
    log "📋 建议手动检查以下内容："
    log "1. 检查Flask应用日志: tail -f /tmp/flask_*.log"
    log "2. 检查Python进程: ps aux | grep python"
    log "3. 检查端口占用: netstat -tlnp | grep 5000"
    log "4. 检查配置文件: cat $APP_DIR/app/config.py"
    log "5. 手动启动测试: cd $APP_DIR && python3 run.py"
    
    exit 1
}

# 执行主函数
main "$@"
